#include "Classe.h"
using namespace std;

string Classe::Caracteristiques[6] =
  {
    "Force       ",
    "Dextérité   ",
    "Constitution",
    "Intelligence",
    "Sagesse     ",
    "Charisme    "
  };

DebugLevelType Classe::elementaire  = INFO;
DebugLevelType Classe::fonction     = INFO;

Classe::Classe()
{}

Classe::Classe(unsigned int xp, unsigned int trait[7], TypeClasse tc)
  : XP(xp)
{
  for(unsigned int i(0); i<7; i++)
    Traits[i] = trait[i];

  Niveau = 0;
  TC = tc;
}

Classe::Classe(const Classe& classe)
{
  XP = classe.XP;
  for(unsigned int i(0); i<7; i++)
    Traits[i] = classe.Traits[i];
  Niveau = classe.Niveau;
  unsigned int taille(classe.Comp_classe.size());
  for(unsigned int i(0); i<taille; i++)
    Comp_classe.push_back(classe.Comp_classe[i]);
  TC = classe.get_TC();
}

Classe::~Classe()
{}

void Classe::affiche() const
{
  dout(BLANK) << "Niveau : " << Niveau << endreq;
}

void Classe::set_Competences(const vector<unsigned int> capa)
{
  unsigned int taille(capa.size());

  for (unsigned int i(0); i < taille; i++)
    Comp_classe.push_back(capa[i]);
    
}

void Classe::affiche_competences() const
{
  dout(BLANK) << "Récapitulation des compétences de classe : " << endreq;
  unsigned int taille(get_combien());
  string comp_str;

  for (unsigned int i(0); i != taille; i++)
    {
      comp_str = get_competence(i);
      dout(BLANK) << " " << comp_str << endreq;
      if (comp_str.find("%") != string::npos)
	i++;
    }
}

string Classe::get_classe() const
{
  return Type_classe;
}

unsigned int Classe::get_XP() const
{
  return XP;
}

unsigned int Classe::get_trait(const unsigned int& i) const
{
  if (i<7)
    return Traits[i];
  else
    return 30;
}

unsigned int Classe::get_combien() const
{
  return Comp_classe.size();
}

unsigned int Classe::get_comp(const unsigned int& i) const
{
  if (i < Comp_classe.size())
    return Comp_classe[i];
  else
    return 255;
}

unsigned int Classe::get_Niveau() const
{
  return Niveau;
}

/******************************************************************************
 *
 * Sert à virer les accents dans le nom des écoles de magies et sphères
 * (écrit en syntaxe latex pour plus de logique)
 * Supprime en même temps le 2ème nom de l'école (càd Illusion - Fantasme =>
 * Illusion)
 * 
 *****************************************************************************/
string Classe::supprime_accents(const string& brut) const
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(elementaire);
  string retour(brut);
  unsigned int loc(retour.find("\\'", 0));
  while (loc != string::npos)
    {
      dout(LFUNC) << retour << ' ' << loc << endreq;
      retour.replace(loc, 2, "");
      loc = retour.find("\\'", 0);
    }

  loc = retour.find(" - ", 0);
  if (loc != string::npos)
    {
      // ici il faut tronquer le nom
      dout(DEBUG) << retour << " ->" << endreq;
      retour.replace(loc, retour.size() - loc, "");
      dout(DEBUG) << retour << endreq;
    }
    

  dout.setLevel(etat_precedent);
  return retour;
}

TypeClasse Classe::get_TC() const
{
  return TC;
}


void Classe::augmenter_xp(const unsigned int& xp)
{
  XP += xp;
  calcul_niveau();
}

void Classe::setLevel(const DebugLevelType& level, const unsigned int& n)
{
  switch(n)
    {
    case 1:
      elementaire = level;
      break;
    case 2:
      fonction = level;
      break;
    default:
      dout(WARN) << "Variable inconnue, dans Classe::setLevel " << n << endreq;
    }
}


void Classe::ajout_sorts()
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(fonction);
  dout(FUNC) << "On est dans Classe, rien à faire ici" << endreq; 
  dout.setLevel(etat_precedent);
}


void Classe::set_Sorts(const vector<Sort>& sorts)
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(elementaire);
  unsigned int taille(sorts.size());

  dout(DEBUG) << "Nbr de sort à copier : " << taille << endreq;

  Cl_sorts.clear();

  for (unsigned int i(0); i < taille; i++)
    Cl_sorts.push_back(sorts[i]);

  dout.setLevel(etat_precedent);
}

unsigned int Classe::get_combien_sorts() const
{
  return Cl_sorts.size();
}

Sort Classe::get_sort(const unsigned int& i) const
{
  if (i < get_combien_sorts())
    return Cl_sorts[i];
  else
    return Sort(0, 0, 0);
}
